home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / formatter.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  15.0 KB  |  570 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import sys
  5. AS_IS = None
  6.  
  7. class NullFormatter:
  8.     
  9.     def __init__(self, writer = None):
  10.         if writer is None:
  11.             writer = NullWriter()
  12.         
  13.         self.writer = writer
  14.  
  15.     
  16.     def end_paragraph(self, blankline):
  17.         pass
  18.  
  19.     
  20.     def add_line_break(self):
  21.         pass
  22.  
  23.     
  24.     def add_hor_rule(self, *args, **kw):
  25.         pass
  26.  
  27.     
  28.     def add_label_data(self, format, counter, blankline = None):
  29.         pass
  30.  
  31.     
  32.     def add_flowing_data(self, data):
  33.         pass
  34.  
  35.     
  36.     def add_literal_data(self, data):
  37.         pass
  38.  
  39.     
  40.     def flush_softspace(self):
  41.         pass
  42.  
  43.     
  44.     def push_alignment(self, align):
  45.         pass
  46.  
  47.     
  48.     def pop_alignment(self):
  49.         pass
  50.  
  51.     
  52.     def push_font(self, x):
  53.         pass
  54.  
  55.     
  56.     def pop_font(self):
  57.         pass
  58.  
  59.     
  60.     def push_margin(self, margin):
  61.         pass
  62.  
  63.     
  64.     def pop_margin(self):
  65.         pass
  66.  
  67.     
  68.     def set_spacing(self, spacing):
  69.         pass
  70.  
  71.     
  72.     def push_style(self, *styles):
  73.         pass
  74.  
  75.     
  76.     def pop_style(self, n = 1):
  77.         pass
  78.  
  79.     
  80.     def assert_line_data(self, flag = 1):
  81.         pass
  82.  
  83.  
  84.  
  85. class AbstractFormatter:
  86.     
  87.     def __init__(self, writer):
  88.         self.writer = writer
  89.         self.align = None
  90.         self.align_stack = []
  91.         self.font_stack = []
  92.         self.margin_stack = []
  93.         self.spacing = None
  94.         self.style_stack = []
  95.         self.nospace = 1
  96.         self.softspace = 0
  97.         self.para_end = 1
  98.         self.parskip = 0
  99.         self.hard_break = 1
  100.         self.have_label = 0
  101.  
  102.     
  103.     def end_paragraph(self, blankline):
  104.         if not self.hard_break:
  105.             self.writer.send_line_break()
  106.             self.have_label = 0
  107.         
  108.         if self.parskip < blankline and not (self.have_label):
  109.             self.writer.send_paragraph(blankline - self.parskip)
  110.             self.parskip = blankline
  111.             self.have_label = 0
  112.         
  113.         self.hard_break = self.nospace = self.para_end = 1
  114.         self.softspace = 0
  115.  
  116.     
  117.     def add_line_break(self):
  118.         if not self.hard_break or self.para_end:
  119.             self.writer.send_line_break()
  120.             self.have_label = self.parskip = 0
  121.         
  122.         self.hard_break = self.nospace = 1
  123.         self.softspace = 0
  124.  
  125.     
  126.     def add_hor_rule(self, *args, **kw):
  127.         if not self.hard_break:
  128.             self.writer.send_line_break()
  129.         
  130.         self.writer.send_hor_rule(*args, **kw)
  131.         self.hard_break = self.nospace = 1
  132.         self.have_label = self.para_end = self.softspace = self.parskip = 0
  133.  
  134.     
  135.     def add_label_data(self, format, counter, blankline = None):
  136.         if self.have_label or not (self.hard_break):
  137.             self.writer.send_line_break()
  138.         
  139.         if not self.para_end:
  140.             if not blankline or 1:
  141.                 pass
  142.             self.writer.send_paragraph(0)
  143.         
  144.         if isinstance(format, str):
  145.             self.writer.send_label_data(self.format_counter(format, counter))
  146.         else:
  147.             self.writer.send_label_data(format)
  148.         self.nospace = self.have_label = self.hard_break = self.para_end = 1
  149.         self.softspace = self.parskip = 0
  150.  
  151.     
  152.     def format_counter(self, format, counter):
  153.         label = ''
  154.         for c in format:
  155.             if c == '1':
  156.                 label = label + '%d' % counter
  157.                 continue
  158.             if c in 'aA':
  159.                 if counter > 0:
  160.                     label = label + self.format_letter(c, counter)
  161.                 
  162.             counter > 0
  163.             if c in 'iI':
  164.                 if counter > 0:
  165.                     label = label + self.format_roman(c, counter)
  166.                 
  167.             counter > 0
  168.             label = label + c
  169.         
  170.         return label
  171.  
  172.     
  173.     def format_letter(self, case, counter):
  174.         label = ''
  175.         while counter > 0:
  176.             (counter, x) = divmod(counter - 1, 26)
  177.             s = chr(ord(case) + x)
  178.             label = s + label
  179.         return label
  180.  
  181.     
  182.     def format_roman(self, case, counter):
  183.         ones = [
  184.             'i',
  185.             'x',
  186.             'c',
  187.             'm']
  188.         fives = [
  189.             'v',
  190.             'l',
  191.             'd']
  192.         (label, index) = ('', 0)
  193.         while counter > 0:
  194.             (counter, x) = divmod(counter, 10)
  195.             if x == 9:
  196.                 label = ones[index] + ones[index + 1] + label
  197.             elif x == 4:
  198.                 label = ones[index] + fives[index] + label
  199.             elif x >= 5:
  200.                 s = fives[index]
  201.                 x = x - 5
  202.             else:
  203.                 s = ''
  204.             s = s + ones[index] * x
  205.             label = s + label
  206.             index = index + 1
  207.         if case == 'I':
  208.             return label.upper()
  209.         
  210.         return label
  211.  
  212.     
  213.     def add_flowing_data(self, data):
  214.         if not data:
  215.             return None
  216.         
  217.         prespace = data[:1].isspace()
  218.         postspace = data[-1:].isspace()
  219.         data = ' '.join(data.split())
  220.         if self.nospace and not data:
  221.             return None
  222.         elif prespace or self.softspace:
  223.             if not data:
  224.                 if not self.nospace:
  225.                     self.softspace = 1
  226.                     self.parskip = 0
  227.                 
  228.                 return None
  229.             
  230.             if not self.nospace:
  231.                 data = ' ' + data
  232.             
  233.         
  234.         self.hard_break = self.nospace = self.para_end = self.parskip = self.have_label = 0
  235.         self.softspace = postspace
  236.         self.writer.send_flowing_data(data)
  237.  
  238.     
  239.     def add_literal_data(self, data):
  240.         if not data:
  241.             return None
  242.         
  243.         if self.softspace:
  244.             self.writer.send_flowing_data(' ')
  245.         
  246.         self.hard_break = data[-1:] == '\n'
  247.         self.nospace = self.para_end = self.softspace = self.parskip = self.have_label = 0
  248.         self.writer.send_literal_data(data)
  249.  
  250.     
  251.     def flush_softspace(self):
  252.         if self.softspace:
  253.             self.hard_break = self.para_end = self.parskip = self.have_label = self.softspace = 0
  254.             self.nospace = 1
  255.             self.writer.send_flowing_data(' ')
  256.         
  257.  
  258.     
  259.     def push_alignment(self, align):
  260.         if align and align != self.align:
  261.             self.writer.new_alignment(align)
  262.             self.align = align
  263.             self.align_stack.append(align)
  264.         else:
  265.             self.align_stack.append(self.align)
  266.  
  267.     
  268.     def pop_alignment(self):
  269.         if self.align_stack:
  270.             del self.align_stack[-1]
  271.         
  272.         if self.align_stack:
  273.             self.align = align = self.align_stack[-1]
  274.             self.writer.new_alignment(align)
  275.         else:
  276.             self.align = None
  277.             self.writer.new_alignment(None)
  278.  
  279.     
  280.     def push_font(self, .1):
  281.         (size, i, b, tt) = .1
  282.         if self.softspace:
  283.             self.hard_break = self.para_end = self.softspace = 0
  284.             self.nospace = 1
  285.             self.writer.send_flowing_data(' ')
  286.         
  287.         if self.font_stack:
  288.             (csize, ci, cb, ctt) = self.font_stack[-1]
  289.             if size is AS_IS:
  290.                 size = csize
  291.             
  292.             if i is AS_IS:
  293.                 i = ci
  294.             
  295.             if b is AS_IS:
  296.                 b = cb
  297.             
  298.             if tt is AS_IS:
  299.                 tt = ctt
  300.             
  301.         
  302.         font = (size, i, b, tt)
  303.         self.font_stack.append(font)
  304.         self.writer.new_font(font)
  305.  
  306.     
  307.     def pop_font(self):
  308.         if self.font_stack:
  309.             del self.font_stack[-1]
  310.         
  311.         if self.font_stack:
  312.             font = self.font_stack[-1]
  313.         else:
  314.             font = None
  315.         self.writer.new_font(font)
  316.  
  317.     
  318.     def push_margin(self, margin):
  319.         self.margin_stack.append(margin)
  320.         fstack = filter(None, self.margin_stack)
  321.         if not margin and fstack:
  322.             margin = fstack[-1]
  323.         
  324.         self.writer.new_margin(margin, len(fstack))
  325.  
  326.     
  327.     def pop_margin(self):
  328.         if self.margin_stack:
  329.             del self.margin_stack[-1]
  330.         
  331.         fstack = filter(None, self.margin_stack)
  332.         if fstack:
  333.             margin = fstack[-1]
  334.         else:
  335.             margin = None
  336.         self.writer.new_margin(margin, len(fstack))
  337.  
  338.     
  339.     def set_spacing(self, spacing):
  340.         self.spacing = spacing
  341.         self.writer.new_spacing(spacing)
  342.  
  343.     
  344.     def push_style(self, *styles):
  345.         if self.softspace:
  346.             self.hard_break = self.para_end = self.softspace = 0
  347.             self.nospace = 1
  348.             self.writer.send_flowing_data(' ')
  349.         
  350.         for style in styles:
  351.             self.style_stack.append(style)
  352.         
  353.         self.writer.new_styles(tuple(self.style_stack))
  354.  
  355.     
  356.     def pop_style(self, n = 1):
  357.         del self.style_stack[-n:]
  358.         self.writer.new_styles(tuple(self.style_stack))
  359.  
  360.     
  361.     def assert_line_data(self, flag = 1):
  362.         self.nospace = self.hard_break = not flag
  363.         self.para_end = self.parskip = self.have_label = 0
  364.  
  365.  
  366.  
  367. class NullWriter:
  368.     
  369.     def __init__(self):
  370.         pass
  371.  
  372.     
  373.     def flush(self):
  374.         pass
  375.  
  376.     
  377.     def new_alignment(self, align):
  378.         pass
  379.  
  380.     
  381.     def new_font(self, font):
  382.         pass
  383.  
  384.     
  385.     def new_margin(self, margin, level):
  386.         pass
  387.  
  388.     
  389.     def new_spacing(self, spacing):
  390.         pass
  391.  
  392.     
  393.     def new_styles(self, styles):
  394.         pass
  395.  
  396.     
  397.     def send_paragraph(self, blankline):
  398.         pass
  399.  
  400.     
  401.     def send_line_break(self):
  402.         pass
  403.  
  404.     
  405.     def send_hor_rule(self, *args, **kw):
  406.         pass
  407.  
  408.     
  409.     def send_label_data(self, data):
  410.         pass
  411.  
  412.     
  413.     def send_flowing_data(self, data):
  414.         pass
  415.  
  416.     
  417.     def send_literal_data(self, data):
  418.         pass
  419.  
  420.  
  421.  
  422. class AbstractWriter(NullWriter):
  423.     
  424.     def new_alignment(self, align):
  425.         print 'new_alignment(%r)' % (align,)
  426.  
  427.     
  428.     def new_font(self, font):
  429.         print 'new_font(%r)' % (font,)
  430.  
  431.     
  432.     def new_margin(self, margin, level):
  433.         print 'new_margin(%r, %d)' % (margin, level)
  434.  
  435.     
  436.     def new_spacing(self, spacing):
  437.         print 'new_spacing(%r)' % (spacing,)
  438.  
  439.     
  440.     def new_styles(self, styles):
  441.         print 'new_styles(%r)' % (styles,)
  442.  
  443.     
  444.     def send_paragraph(self, blankline):
  445.         print 'send_paragraph(%r)' % (blankline,)
  446.  
  447.     
  448.     def send_line_break(self):
  449.         print 'send_line_break()'
  450.  
  451.     
  452.     def send_hor_rule(self, *args, **kw):
  453.         print 'send_hor_rule()'
  454.  
  455.     
  456.     def send_label_data(self, data):
  457.         print 'send_label_data(%r)' % (data,)
  458.  
  459.     
  460.     def send_flowing_data(self, data):
  461.         print 'send_flowing_data(%r)' % (data,)
  462.  
  463.     
  464.     def send_literal_data(self, data):
  465.         print 'send_literal_data(%r)' % (data,)
  466.  
  467.  
  468.  
  469. class DumbWriter(NullWriter):
  470.     
  471.     def __init__(self, file = None, maxcol = 72):
  472.         if not file:
  473.             pass
  474.         self.file = sys.stdout
  475.         self.maxcol = maxcol
  476.         NullWriter.__init__(self)
  477.         self.reset()
  478.  
  479.     
  480.     def reset(self):
  481.         self.col = 0
  482.         self.atbreak = 0
  483.  
  484.     
  485.     def send_paragraph(self, blankline):
  486.         self.file.write('\n' * blankline)
  487.         self.col = 0
  488.         self.atbreak = 0
  489.  
  490.     
  491.     def send_line_break(self):
  492.         self.file.write('\n')
  493.         self.col = 0
  494.         self.atbreak = 0
  495.  
  496.     
  497.     def send_hor_rule(self, *args, **kw):
  498.         self.file.write('\n')
  499.         self.file.write('-' * self.maxcol)
  500.         self.file.write('\n')
  501.         self.col = 0
  502.         self.atbreak = 0
  503.  
  504.     
  505.     def send_literal_data(self, data):
  506.         self.file.write(data)
  507.         i = data.rfind('\n')
  508.         if i >= 0:
  509.             self.col = 0
  510.             data = data[i + 1:]
  511.         
  512.         data = data.expandtabs()
  513.         self.col = self.col + len(data)
  514.         self.atbreak = 0
  515.  
  516.     
  517.     def send_flowing_data(self, data):
  518.         if not data:
  519.             return None
  520.         
  521.         if not self.atbreak:
  522.             pass
  523.         atbreak = data[0].isspace()
  524.         col = self.col
  525.         maxcol = self.maxcol
  526.         write = self.file.write
  527.         for word in data.split():
  528.             if atbreak:
  529.                 if col + len(word) >= maxcol:
  530.                     write('\n')
  531.                     col = 0
  532.                 else:
  533.                     write(' ')
  534.                     col = col + 1
  535.             
  536.             write(word)
  537.             col = col + len(word)
  538.             atbreak = 1
  539.         
  540.         self.col = col
  541.         self.atbreak = data[-1].isspace()
  542.  
  543.  
  544.  
  545. def test(file = None):
  546.     w = DumbWriter()
  547.     f = AbstractFormatter(w)
  548.     if file is not None:
  549.         fp = open(file)
  550.     elif sys.argv[1:]:
  551.         fp = open(sys.argv[1])
  552.     else:
  553.         fp = sys.stdin
  554.     while None:
  555.         line = fp.readline()
  556.         if not line:
  557.             break
  558.         
  559.         if line == '\n':
  560.             f.end_paragraph(1)
  561.             continue
  562.         f.add_flowing_data(line)
  563.         continue
  564.         f.end_paragraph(0)
  565.         return None
  566.  
  567. if __name__ == '__main__':
  568.     test()
  569.  
  570.